package com.tedu.api.list;

import com.tedu.api.PackingAPI;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * 数组：遍历数据  遍历数据三种：普通for，增强for，Arrays工具类
 * √集合：遍历数据 遍历数据三种：普通for，增强for，Iterator工具类
 * 保存数据优选：集合---遍历数据优选Iterator迭代器
 * Iterator迭代器        接口---依赖Collection提供方法：Iterator()
 *
 * 集合：迭代器的使用方法：问，取，删（不是必须操作）
 *
 */
public class Collection_IteratorAPI<intArray> {
    @Test
    public void testIterator(){
        Collection c1=new ArrayList();
        c1.add("one");c1.add("two");c1.add("three");
        /**
         * Iterator()方法：获取集合的迭代器---遍历数据
         */
        Iterator it =c1.iterator();
        //迭代器使用：1.问--集合中是否存在元素【集合元素不确定】
        /**
         * hasNext()  返回值：Boolean
         * 作用：判断集合中是否还有元素可以遍历，返回true有元素，false没有元素
         */

        while(it.hasNext()){//迭代器：问操作--hasNext()
            //2.取--如果集合中存在元素：取出元素--next()
            /**
             * E next()     返回值：E泛型  简单理解：Object
             * 作用：遍历取出元素
             */
            String str=(String)it.next();
            System.out.println("集合迭代器："+str);

        }
    }
    /**
     * 集合中三种遍历方式：Iterator迭代器【问，取操作】
     *                 普通for【难度，需要API】 √
     *                 增强for【没有难度】     √
     *                 开发：选一种使用
     *                 遍历同时对集合做元素删除操作--Iterator
     */
    @Test
    public void testFor(){
        //创建集合
        Collection Collection=new ArrayList();
        //需求：10个元素，普通for增加元素：0~9数值
        for(int i=0;i<10;i++){
            Collection.add(i);
        }
        System.out.println("打印集合数据："+Collection);
        //获取集合中所有数据-------操作：遍历
        //①使用普通for遍历Collection集合，提醒：查API
        //获取数组元素：int[] arr={1,2,3};     数组名[下标] arr[1]
        //获取集合元素：List--方法get()         集合名[下标]  ×
        for(int i=0;i<Collection.size();i++){//i值:拿下标
            System.out.println("增强for遍历集合："+((List)Collection).get(i));
        }
        //②使用增强for遍历：语法：for(Integer i:集合名){}
        //                       for (Object i:Collection)
        //Collection是顶级集合--存任何数据--object类型
        for (Object i:Collection){
            System.out.println("增强for遍历集合："+i);
        }
    }
    /**
     * 遍历同时对集合做元素删除操作--Iterator
     * Iterator迭代器--删除操作【真删】
     * remove()      返回值：void
     * 作用：删除迭代器获取的元素【理解：next()取元素之后，删除】
     * Iterator迭代器使用规则：问，取，删
     *
     * 作业：增强for循环，删除testRemove单元测试中集合包含“元旦”的元素
     *     作业单元测试名：testHomeWork()
     *
     */
    @Test
    public void testRemove(){
        Collection c=new ArrayList();
        c.add("十一");c.add("元旦");c.add("春节");c.add("元宵节");
        //1.
        System.out.println("Collection集合："+c);
        Iterator it=c.iterator();
        //2.使用迭代器：问，取，删
        while(it.hasNext()){
        //3.获取集合中的元素  next() 获取集合中元素，默认类型Object
        String str=(String) it.next();
        //4.删除集合中存在春节的元素
        //4.1如果集合中元素名春节--删除
        if("春节".equals(str)) {
            it.remove();//next()拿到元素之后删除
        }
            //  c.remove("春节");  //集合中删除
        }
        System.out.println("迭代器实现删除元素操作："+c);
    }



    /**
     * 泛型：与集合搭配使用   E element 元素  理解：Object
     * JDK1.5之后推出新特性，集合可以存任何数据，获取数据很混乱
     *                 对象，整数，小数型 取 Object 知道类型
     *泛型主要功能是约束集合的类型
     * 泛型编译器认可的，JVM虚拟机不认可，认为：Object对象
     * 使用泛型好处：1.约束类型，数据稳定【统一类型】,获取元素无需造型
     *            2.类型：对象--继承以及继承之后方法的使用super
     * 语法：
     * Collection<类型：引用类型，基本类型，包装类型> c=
     * new ArrayList<类型：引用类型，包装类型>();
     */
    @Test
    public void testElement(){
        //JDK1.5 泛型写法
        Collection<String> c1=new ArrayList<String>();
        //JDK1.7 泛型写法    建议使用
        Collection<String> c2=new ArrayList<>();
        c2.add("老六");   c2.add("老七");  c2.add("老八");
        Iterator<String> it= c2.iterator();
        while (it.hasNext()){  //问：存在数据，存在true
            String str= it.next();
        }

        //泛型
        Collection<?> c4=new ArrayList<>();
        /**
         * c4.add("字符串");c4.add(1);
         *          c4.add(new Object());
         */
    }
    /**
     * 反省中通配符 ？【任意类型】 的使用
     * ？【任意类型】 extends 父类
     * 【任意类型：父类的所有子类】   --约束--
     */
    @Test
    public void testE(){
       //测试：创建集合--传入参数：引用类型：Apple对象
        Collection<Apple> apples=new ArrayList<>();
        apples.add(new Apple());  //存入apple对象
        TestJob.printFruit(apples);
        Collection<Orange> oranges=new ArrayList<>();
        oranges.add(new Orange());
        TestJob.printFruit(oranges); //上界限定操作：针对集合

        Collection<pear> pears=new ArrayList();
        pears.add(new pear());
      //  TestJob.printFruit(pears); //上界限定操作：针对集合

    }
    }

